import Web3 from 'web3';
import bigDecimal from 'js-big-decimal';

/**
 * To bytes32
 * @param hex
 * @returns
 */
export function hexToBytes(hex) {
  return Web3.utils.sha3(hex);
}

// 数字格式化过滤器
export function numberFormat(value) {
  // 判断值是否为 null
  if (value === null) {
    return '0';
  }
  // 判断值是否为字符串或数字
  if (typeof value !== 'string' && typeof value !== 'number') {
    return '0';
  }
  // 转换为数字类型
  const numberValue = typeof value === 'string' ? parseFloat(value) : value;
  // 判断是否为数字
  if (isNaN(numberValue)) {
    return '0';
  }
  // 使用 Intl.NumberFormat 格式化数字，并返回格式化后的字符串
  return new Intl.NumberFormat('en-US').format(numberValue);
}


/**
 * 校验只要是数字（包含正负整数，0以及正负浮点数）就返回true
 */
export function isNumber(val) {
  var regPos = /^\d+(\.\d+)?$/ // 非负浮点数
  var regNeg =
    /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/ // 负浮点数
  if (regPos.test(val) || regNeg.test(val)) {
    return true
  } else {
    return false
  }
}

/**
 * 浮点数位数处理，默认保留2位小数
 * @param {Number} f 需要处理的参数
 * @param {Number} digit 保留的小数点位数
 * @return {Number}
 */
export function decFloat(f, digit = 2) {
  if (isNumber(f)) {
    const m = Math.pow(10, digit)
    return parseInt(decMul(f, m, -1), 10) / m
  } else {
    return 0
  }
}
/**
 * 加法
 * @param {Number} num1 加数
 * @param {Number} num2 加数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相加后的结果
 */
export function decAdd(num1, num2, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1Digits = (num1.toString().split('.')[1] || '').length
    const num2Digits = (num2.toString().split('.')[1] || '').length
    const baseNum = Math.pow(10, Math.max(num1Digits, num2Digits)) // 放大倍数baseNum是‘两个小数点后面长度这两者之间的最大值’
    const calcValue = (decMul(num1, baseNum) + decMul(num2, baseNum)) / baseNum
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}

/**
 * 减法
 * @param {Number} num1 被减数
 * @param {Number} num2 减数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相减后的结果
 */
export function decSub(num1 = 0, num2 = 0, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1Digits = (num1.toString().split('.')[1] || '').length
    const num2Digits = (num2.toString().split('.')[1] || '').length
    const baseNum = Math.pow(10, Math.max(num1Digits, num2Digits)) // 放大倍数baseNum是‘两个小数点后面长度这两者之间的最大值’
    const calcValue = (decMul(num1, baseNum) - decMul(num2, baseNum)) / baseNum
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}
/**
 * 乘法
 * @param {Number} num1 乘数
 * @param {Number} num2 乘数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相乘后的结果
 */
export function decMul(num1 = 0, num2 = 0, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1String = num1.toString()
    const num2String = num2.toString()
    const num1Digits = (num1String.split('.')[1] || '').length
    const num2Digits = (num2String.split('.')[1] || '').length
    const baseNum = Math.pow(10, num1Digits + num2Digits) // 放大倍数baseNum是‘两个小数点后面长度之和’

    const calcValue =
      (Number(num1String.replace('.', '')) *
        Number(num2String.replace('.', ''))) /
      baseNum
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}

/**
 * 除法
 * @param {Number} num1 被除数
 * @param {Number} num2 除数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相除后的结果
 */
export function decDiv(num1 = 0, num2 = 0, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1String = num1.toString()
    const num2String = num2.toString()
    const num1Digits = (num1String.split('.')[1] || '').length
    const num2Digits = (num2String.split('.')[1] || '').length
    const baseNum = Math.pow(10, num1Digits + num2Digits) // 放大倍数baseNum是‘两个小数点后面长度之和’
    let n1 = decMul(num1, baseNum)
    let n2 = decMul(num2, baseNum)

    const calcValue = Number(n1) / Number(n2)
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}

export function formatBigIntToString(val, decimals) {
  // console.log('formatBigInt',val)
  // const result = BigInt(val * 10 ** decimals).toString();
  var n1 = new bigDecimal(val);
  var n2 = new bigDecimal(10 ** decimals);
  var result = n1.multiply(n2);
  console.log('formatBigInt', result)
  return result.value;
}
